perm filename LRNMUS.GL[UP,DOC] blob
sn#153369 filedate 1975-04-05 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00011 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 ABSTRACT
C00004 00003 STEP BY STEP INSTRUCTIONS FOR A BASIC SOUND PROGRAM.
C00013 00004 INPUT FOR MUSIC PROGRAMS:
C00022 00005 MUSIC COMPILER, WORD CONVERSION, AND D/A PROGRAMS:
C00029 00006 ANALOG ASPECTS
C00032 00007 MISCELLANEOUS TECHNIQUES:
C00034 00008 MISC. FILES AND PROGRAMS
C00045 00009 APPENDIX NEWMUS
C00047 00010 CHANGES, ADDITIONS, ODDS AND ENDS
C00051 00011 ABRIDGED EDIT MODE COMMAND LIST
C00060 ENDMK
C⊗;
ABSTRACT
LRNMUS is an information source for general music synthesis programs.
Familiarity with the Monitor Command Handbook, MUSIC.TVR[UP,DOC], and
SCORE.LCS[UP,DOC] is assumed exept for the STEP BY STEP INSTRUCTIONS
FOR A BASIC SOUND PROGRAM which can be waded through by beginners
with some help. Knowledge of SAIL (or ALGOL) is not essential,but
strongly recomended. This file further assumes the user has access to
someone familiar with AI Lab music programs who can fill in the gaps
which will undoubtedly exist between what you want to know and what
is supplied here. This file attempts only to anticipate the broadest
questions of procedure. "Ours is not the reason why..."
STEP BY STEP INSTRUCTIONS FOR A BASIC SOUND PROGRAM.
NOTE: Statements in quotes are computer responses to your actions.
I've left out a lot of things in this section that might be helpful
(like how to recover from some mistakes) in the interest of coherency.
Also, changes can be expected in the programs at any time which may
not be reflected here.
First it is necessary to connect the digital to analog converter (DAC
or DA) to a loudspeaker, either the four track facility in the music
room or the monitor speaker attached to your console. The easiest
thing is to hook up the console speaker for which you type <break>4U.
There is a volume knob attached to the speaker box, turn it to
half-way. To connect the 4 channel sound system, find the section on
ANALOG ASPECTS and MONITOR SPEAKERS on page 6, follow those
directions
and report back here.
Type:
R NEWMUS
NEWMUS is a music compiler which will take all the following
information and from it compute the waveform and play it.
"INPUT?"
When NEWMUS says this, it is expecting a file name. We're
not dealing with that yet so type:
<cr>
(that means carriage return). NEWMUS will type:
">"
O.k., now NEWMUS will accept input from your console, so
type:
SETSPEED;
Note the existance and location of the semicolon. Semicolons
must end all declarations and statements (with exceptions as
noted).
SETSPEED controls the number of channels and the speed that
NEWMUS will compile the intrument we will write.
"number of channels:" (you type:) 1 <cr>
"sample rate:" (you type:) 25000 <cr>
"SPEED=2."
">"
Ready for more input so type:
ARRAY F2 (512);
"ARRAY F2"
">"
This creates an array of 512 locations numbered from 0 to
511 in which we will store the shape of a wave used in our
basic instrument. The array is called F2. F1 is already
supplied by NEWMUS and is loaded automatically with
numbers representing a sine wave. The name F2 ("function" 2)
is arbitrary. Remember to put the semicolon after the declaration.
This terminates the list of declarations required for our purposes.
There could also be other things here such as a VARIABLE statement,
which just says that such-and-such a letter or word,etc. exists as a
location in the memory that can store a value. Now to specify the
shape of the arrays, type:
SEG(F2); You will be put into a graphic representational mode.
Type:
0 0 <cr>
and note the result. The first number is the amplitude
(y axis), the second is the x axis increment at which this
amplitude will be. Succeeding pairs of numbers just continue
this process until the number 100 is reached.
1 10 <cr>
0 100 <cr>
If after you reach 100 you type <cr>, the function will display.
To end the display type:
0<cr>
">"
If you want to see what the function looks like again, type:
SEE(F2);
When you're through, type:
0<cr>
F1 was supplied by NEWMUS and was constructed by SYNTH,
which operates like SEG. See pg.∀.
Next comes the instrument definition. Type:
INSTRUMENT FUT;
OSCIL(P4,MAG/P2,F2);
OSCIL(U1,MAG*P3,F1);
OUTA←OUTA+U2;
END;
See page 4 for an explanation of these terms.
"INSTRUMENT FUT"
That tells you you did everything o.k. and that FUT
exists as a valid instrument.
Next comes the list of parameters which the instrument will play. Type:
PLAY DA:1.0; FUT 0 1 440 1000;FINISH;
DON'T EVER LEAVE A SEMICOLON (or colon) OFF!!!
Now the computer is gobbling up your data and spewing out numbers
into an output file. It should be left alone. This sound seldom
takes more than a minute to compute. Longer sounds take
proportionally more time. You should have either fired up the four
track setup (as per ANALOG ASPECTS) or attached your monitor speaker
to the DA, because suddenly, when you least expect it, a sound well
LEAP! out at you.
If you wish to hear it again, type:
<alt>P<cr><alt> When you type the second <alt>, you get the sound again.
To make the sound louder, turn the volume knob to the right.
If you want to play a different note with this same instrument, rewrite the
PLAY statement using the following as a guide.
When writing a PLAY statement directly into NEWMUS like you are doing
put the entire statement on one line. Follow the format as above
until the first number after the word FUT. These four numbers
are the four parameters we have declaired in the instrument deffinition
as P1,P2,P3 and P4.
-The first number (P1) tells NEWMUS how long after the beginning
of the playback the note is to sound. Since we are playing only
one sound we want it to be 0 so we will hear it imediately.
-The second number is the length of the note to be played. One
second is recommended because the computing time is short.
If you are experimenting, it wastes less time. But if you want to
change it, you must also change the number after "DA:" to match.
-P3 is the pitch of the note. Write either the frequency (Hz) of
the note, or for the equal tempered tuning, a letter from A - G.
Sharps are possible by following the letter imediately with S.
-P4 is the volume of the note. Any value between 0 and 2047 will do.
Example of another note:
PLAY DA:5.0 FUT 0 5 AS 2000; FINISH;
When you are through, leave NEWMUS by typing:
<alt> EXIT <cr>.
the computer then puts you back to monitor mode:
"EXIT"
"↑C"
INPUT FOR MUSIC PROGRAMS:
Input is made up of an instrument definition, a parameter list,and
other information the compiler needs which we'll call the
initializing list. The Stanford music compiler reads this information
from one or more files. Creating several files for this information
is suggested. However, all the statements , declarations, etc.
described below can be added from the console directly into NEWMUS.
See page 3. The advantage is flexibility in seting things up, the
disadvantage is that you must then retype the entire event if you
either leave the NEWMUS environment, or want to change something
after it has been compiled.
INITIALIZING LIST:
Create a file (maybe called INIT, or something). Into it put the
following declarations:
SETSPEED;<# OF CHANNELS> <SAMPLING RATE> (don't forget ;)
(typical values: SETSPEED; 1 25000). This sets the sampling rate.
ARRAY F2,F3,...,Fn(512);
F2,...Fn are functions (sine waves, envelope functions, etc.)
to be loaded with the instrument. (512) is the current size of a
memory block. F1 is always supplied with NEWMUS as a sine wave.
This can be overriden of course.
VARIABLE ⊂variable name⊃,⊂v.n.⊃,⊂v.n.⊃;
A number of variables
are specified in NEWMUS automatically, such as the letters of the
musical scale with their Hertz numbers (see APPENDIX NEWMUS).
You can create variables for other purposes with the above format.
Other things can go into this file, for instance, you can tell
yourself the next file to read by writing:
PRINT "Next file name";
When the music compiler (NEWMUS) loads this file, it will print
this statement afterwards.
Basicly you want to put everything in the initialization list
that you don't want to have to declare over and over again.
INSTRUMENT LIST
Create a file for your instrument definiton.
Now that you have arrayed the functions, specify their shape with either
SYNTH or SEG, e.g.:
SYNTH(F2); 1 1 999
(Note the location of the ;.)
This creates in F2 a sine wave with harmonic 1 (the fundamental) and
amplitude 1. 999 terminates the SYNTH list. There is an extended mode:
SYNTH (F2); 99 1 1 90 1 999
where 99 enters the mode,
harmonic = 1, amp.=1, phase angle =90degrees, offset constant=1, 999term.
SEG(F3); 0 0 1 1 0 100
(Note the semicolon.)
This allows functions to be drawn in line segments. The function
described has amplitude 0 at location 0, amp. 1 @ loc.1, 0 @ 100.
Typing location # 100 terminates SEG. SYNTH and SEG functions can be
created while runing NEWMUS, and will display the waveform. Just type
the above statements up to the ";", then hit ⊂cr⊃. The waveform will
begin displaying and instructions on how to alter it will be printed.
You can see existing functions graphicly in NEWMUS by typing SEE
(<function name>);.
Now the instrument:
INSTRUMENT FUT;
OSCIL(P4,MAG/P2,F2);
OSCIL(U1,MAG*P3,F1);
OUTA←OUTA+U2;
END;
where:
INSTRUMENT <name>;
begins the instrument list. This is a special kind
of DO list which the music compiler can read. Like any DO
list, it must be terminated by END; see below.
OSCIL(<amplitude>,<frequency>,<function>);
There are many kinds of oscils.
See the MUSIC MANUAL listed in FILES, page 8 below.
MAG
is the magic number specifying the ratio of 512/sample rate.
The length of stored functions in NEWMUS is 512 samples long. The
ratio (512/sampling rate) establishes a base frequency which when
mulltiplied by the desired frequency number (in this case,P3) will
sample the 512 increment long function at intervals which will
produce the desired frequency. A further explanation of this subject
can be found in MUSIC.TVR[UP,DOC]. This is also a good question for
a music programer.
Pn is a parameter number.
Un is the output of a unit generater(numbered in order of entry)
OUTA is the output block absorbing this instrument.
END;(←note semicolon;) this ends the instrument list.
Comments can be added to this or any list by typing:
COMMENT say anything here until you write a semicolon;
Alternate comment form:
< say anything here until a semicolon;
INSTRUMENT WRITING CONSIDERATIONS:
Newmus is set up so that P1 always determines the begin time of the
instrument. For instance, if you want FUT to play at time 0, P1 would
be listed in your note list as 0. Also, P2 is reserved to represent
the total duration of the note being played. So, P2 does two things:
it tells the system how long to make the file the instrument will
play into, and it also is available to determine the length of time
the instrument will actually play. You CAN have the instrument's
duration controled in another variable, but P2 must still be in the
note list to represent the length of the file the instrument will
read into. This information is given here instead of under the
parameter list heading below because it affects how you define your
instruments as well as how you write their note lists.
PARAMETER LIST
Here's where you tell the instrument what to play.
Create a file for parameters.
PLAY;INSTRUMENT NAME P1 P2 P3 P4 ...Pn;
The parameter list must! end with
FINISH;
The play statement is like a specialized block in SAIL with PLAY;
replacing BEGIN, and FINISH; for END;
Please see INSTRUMENT WRITING CONSIDERATIONS above.
MUSIC COMPILER, WORD CONVERSION, AND D/A PROGRAMS:
The NEWMUS compiler will be used here. SCORE does much of the same
kinds of things, (it is either more efficient or less efficient than
NEWMUS depending on what you want to do) and is well documented in
SCORE.LCS[UP,DOC].
NEWMUS:
NEWMUS is a compiler, and is the vehicle by which instruments
are coupled with their parameters. One or more files are
created to contain the numeric representations of the waveform.
Type:
R NEWMUS
After some preliminary statements, it types:
Input:
Type file names of initialization, instrument, & note lists
one at a time. When it says "Input?" it expects a file name.
To do anything else, like to make declarations, write
functions, or to write instruments, etc. type ⊂cr⊃ first. To
return to input mode, type ⊗⊂cr⊃. If you get an error message
"Storage full", type <CALL>, and restart using the FREEZE
method, see below. Among the variables that are given with
NEWMUS are the Hz for pitches of the equal temperament scale:
A:440, AS(A SHARP):466.16,...GS. See APPENDIX NEWMUS. Array
F1 is given as a simple sine wave. If you want to watch it
compile, see MONITE[1,MUZ] below:
Output:
<alt> EXIT
Name a file for storage of computed samples. There should be an
integer(or letter) extention to the file name (e.g. TEST.1).
This is because,if your sound file will be longer than about two
seconds, NEWMUS will
automatically create more files with extensions n+1 to contain it.
"MAX AMP" is part of data printed when compilation is complete
used to indicate the largest sample. Remember it.
If you have no more input, then type:
NMUSIO:
NMUSIO is a program which converts one or more 18 bit sound files
as produced by NEWMUS into one long 12 bit soundfile acceptable
as input to the D/A converter.
Type:
R NMUSIO
Input:
Type NEWMUS output file name. If NEWMUS created more than one file
for output (the extension is incremented one for each additional
file created),load the files this way: <filename.ext>-<last ext>.
For instance:FOO.1-6.
Output:
Make up a storage location. Since this will be a sound file,you
might want to use the extension capability to identify this.
Convert to 12 bit?
Y(es). <cr> will copy input file into output without conversion.
Max Amp: (Write it in here, or <cr> and NMUSIO will find the figure.)
NMUSIO then converts the files and types:
More input?
If NEWMUS had to create more files, you add them here, so
answer Y(es); Else N(o).
Input:
Write in the additional file name and that file will be joined to the
end of the new file.
Finishing input?
Y or N. NMUSIO will CALL itself.
The two follownig programs play the sound files through the DA.
R DSKPLY
will explane itself. (honist!)
This program will play sound files even if the XGP is busy.
Set up the sound file, and continue to default (tnat is, type
<cr> every time) until it says GO?... then Y(es).
To leave DSKPLY,type call, then F<cr> to make sure the XGP is
unhooked from your job.
For an alternate way to play sounds, type:
R MPLA to play multiple lists. TTY types:
> (put file name here, then <cr>)
> (if more files are to be played add them here, else just <cr> again).
Play it? Y(es).
If you want to play a different file, N(o).
If you are going to play more than one speaker,
after Input? type <S><cr>. Then either accept or replace values of
variables.
Leave MPLA by doing an <alt>X, rather than a
<call> or else you will leave the XGP assigned to your job and somebody may
come looking for you...
(Question of the week, "What does the XGP have to do with the DAC, anyway?
Answer: they both are controled from the PDP 6 which is not big enough for both.
ANALOG ASPECTS
Music room:
Switch in back of silver volume box beside Scully 280,
if up, moniters the decks inside the cabinet, if down, the Scully.
Scully must be in record mode, with volume up for channels outputing.
Set Record level to about 5, Input to Line. Put Dolby in Rec mode.
D/A:
Sampling rate of the 4 channel d/a is usually set at 25khz, with the
corresponding low-pass filter cutoff of 12.5khz.
If you have reason to believe the d/a needs to be adjusted, it exists
at KLUDGE BAY 2 in the machine room. The d/a proper is the topmost
chasis. The bottom most chasis is the filter.
Switch positions: channels 4 3 2 1 left to right as you look
at them.
A/D Nothing is known at this point about the a/d.
MONITOR SPEAKERS
If you are not working in the music room, you can switch the TTY
audio channel to channel 1 of the D/A by typing BREAK 4 U (See Audio
Switch Control, 2.9, Monitor Command Manual). BUT the D/A will also
output to the music room,and if there are people using the D/A there,
they will be clobered by your sounds. So, send them a message to
expect your sounds, as it is quite unnerving to be jolted out of
meditation by another's static. See MAIL in Monitor Command. Ttys 24
and 45 are the ones in the musiic room.
Or you might move your project to the music room to play your sounds. Type:
AL ⊂prj,prg⊃ ⊂cr⊃ to alias to a tty in the music room.
AL ⊂cr⊃ returns the tty to its previous user. Or,
DET(atch) your job, move to an unused tty in the music room and
ATTACH ⊂job #⊃ [prj,prg] ⊂cr⊃. You are now attached to the new tty.
******
MISCELLANEOUS TECHNIQUES:
FREEZE METHOD:
If you get squeezed for core, start over doing the following:
R NEWMUS 25 (this specifies 25K core)
now add input files.
After compilation write
⊂ALT⊃FREEZE
when frozen, exit to moniter and write
SAV ⊂filename, anything besides NEWMUS⊃
Your program will be saved in the required core.
You now have a dump file with that filename which contains,
besides NEWMUS, all the data you have put into it.
Address it as follows:
RU ⊂dump file name⊃
EDITING FROM NEWMUS:
Given an error in an input list, you have the option to edit the
error in the file without leaving the NEWMUS environment. Type E, the
program then moves to the location of the error. Correct it, then type
⊗X,then GO to return to your location in NEWMUS.
MISC. FILES AND PROGRAMS
INFORMATION FILES:
MUSIC.TVR[UP,DOC]
SCORE.LCS[UP,DOC]
USEMUS.MAN[MAN,LCS] FOR MUSIC 10
FUNC, a program for using lightpen to write functions, and/or
to write functions into files. Lightpen works only from III's.
Type
R FUNC
After it enters, type ⊂cr⊃. It will say
SEG OR SYNTH?
Say either, usually SEG.
When the graph is displayed, type L for lightpen, move
lightpen to location of the circle of dots, push button on
lightpen, and draw. To fix a point, hold lightpen at
location, type ⊂cr⊃. Follow directions until it says
ADD TO EXISTING FILE?
type N(o). Then it will ask
TYPE FILE NAME
write a filename without extension. Then it will say
TYPE FUNCTION NAME
so write in a function name.
It will create the file with the extension .DAT.
You can refrence this file from NEWMUS like any other file.
Later, add functions to this file by saying Y(es) to
"ADD TO EXISTING FILE?"
FUNKY[MIX,MUZ] a file for manipulating arrays.
FUNKY.INF[MIX,MUZ] for information on FUNKY.
WAVE[1,MUZ] a program to display samples of a sound created
with NEWMUS. It will not take files with extensions. Copy the file
into a file without one, then RU WAVE[1,MUZ] and do what it says.
MONITE[1,MUZ] a file containing the instrument MONITER, used to
display word blocks in NEWMUS while they are being computed. It
isn't an instrument you will hear, but a kind of visual loudspeaker.
So it's function is to display another instrument . So load it with
your instrument, and write a parameter list for MONITER where
P1=starting time, P2=duration, P3 is the amplitude, and P4 is how
often to display. Typical values might be 0 1 1000 2;
S This is a program, not a file, containing a display program for viewing
sound files in 12 bit and other formats. It also contains filters
(lowpass, hignpass). It has some internal documentation. Type:
R S It will type:
*
For information type either "?" or HELP, or see JAM. Good luck!
RU CREV[MIX,MUZ] a file for creating reverb instruments. For info. type
HELP. You want to treat the file like an automatic equation solver. The
equation takes two supplied values and finds the third. The variables are
Reverb_time,Gain,& Delay_time. To solve for Gain as the unknown type G,
then enter values for the other two independent variables.
When the solution is reached, CREV will write those values into a unit
generator and put it in a file for you. See Loren Rush for details (MUZ).
Suggested delay factor between unit generators: .8, gain factor .94.)
Writing good reverb instruments is an intuitive gift.
EGEN [GL,JAM], a file of envelope generators to be used in NEWMUS.
EGEN.INF[GL,JAM], for information on EGEN.
NOTICE: Programs and files sometimes change location. If you are looking
for a file listed here or anywhere, and the computer doesn't find it,
try the following, type to the monitor:
DIR <filename>.<ext>[*,PRG]|[PRJ,*]
The first option will search for the file through all the programer's
projects, the second option will search through all progects, matching
them against the filename. For example:
DIR FUNKY.INF[*,MUZ] will search MUZ for a project that has FUNKY.INF.
APPENDIX NEWMUS
Pitches given in NEWMUS:
A 440
AS 466.16
B 493.89
C 261.62
CS 277.18
D 293.66
DS 311.13
E 329.63
F 349.23
S 369.99
G 391.99
GS 415.31
*************
If computation is interrupetd in NEWMUS for any reason (such as
a parity error, if you type CALL accidently, etc.) restart by typing:
RU <NEWMUS_output_file_name>.SAV <cr>. That will start it again at
the point it was terminated.
If you wish to see a listing of parameters introduced to NEWMUS, type
<alt>LIST<cr> this lists all variables and arrays declared.
<alt>VARIABLE " " " " .
<alt>ARRAY " " " " .
CHANGES, ADDITIONS, ODDS AND ENDS
It is now possible to play sounds through the d/a as soon as they are
compiled in NEWMUS. To do so, add the code "DA:n.n" where n is the length
of the sound file to be played in seconds (don't write integer values,the
dot is aparently necessary). This statement is placed in the PLAY statement
thus:
PLAY DA:1.0; FOO 0 1 A 1000;FINISH;
Once the sound has played once in NEWMUS, it can be played again immediately
by typing from TTY mode:
<alt>P<cr><alt>
and the sound will play when you type the second <alt>.
If you are doing a long compute in NEWMUS, and you want to stop it, or it
stops itself for some reason (error, etc.) it can be restarted by the following:
RU<output_file_name>.SAV and it will start up where it left off.
Furthermore, the job that is doing the compute can be detatched from your
terminal but still continue running by doing the following:
Start the compute
type C↑
type CF
type KATT<job_number> (that stands for kill attached job).
Within an instrument it is possible to write a statement that will be
executed only at the time the instrument is being used to generate its
waveform. The format is:
INSTRUMENT <name>;
I_ONLY
<statements>
END;
<continuation_of_instrument_list>;
END;
******
USEFUL TIDBITS:
MAG/Pn(usually pn←p2) is note duration. MAG*Pn is fqy.
Maximum amplitude processed by the d/a = 2047.
PRINT ⊂string⊃; will print the values, assuming they exist.
SEE (array); will display it.
PUT (FUNCTIONn ⊂from 0→512⊃)⊂number⊃; to change an
increment in a function.
<alt>VARIABLE writen in NEWMUS will list all available variables.
<alt>FUNCTION " " " " " " " functions.
<alt>LIST will list everything indiscriminantly.
C<space>0 will release the XGP,DA, other device attached by MPLA, etc.
WHO<space>R | M : R=system run time display; M=your own programs.
ABRIDGED EDIT MODE COMMAND LIST
α MEANS ⊂CONTROL⊃ KEY
β " ⊂META⊃ "
⊗ " ⊂META-CONTROL⊃
<cr> " ⊂RETURN⊃
| " YOU HAVE A CHOICE BETWEEN WHAT`S IN THE BRACKETS
The E editor is an aid to writing files. It supplies a list of commands
with which files can be writen quickly and easily. To learn the commands,
get to the monitor level, and type:
HELP ETEACH with a carriage return and follow instructions.
Another information source is in E.ALS[UP,DOC] which can be addressed
either from the monitor, or while editing a file. Enter a file by typing:
ET <filename><cr> as usual, then type α? (that is, <CONTROL>?).
The following list is incomplete, possibly inaccurate, and probabily misleading.
E EDITOR MODE COMMANDS
ET ⊂FILENAME⊃ TO EDIT A FILE
CET ⊂FILENAME⊃ TO CREATE A FILE.
MISC.
⊂FORM⊃ KEY WINDOWS AND PAGES AUTOMATICALLY.
⊗P GOES TO NEXT PAGE
⊗W MOVES BOTTOM LINE TO TOP.
⊗J " CURRENT " " " .
⊗L " TOP " " BOTTOM.
⊗⊂PAGE #⊃⊗P MOVES TO THAT PAGE.
⊂alt⊃ ERASES COMMANDS.
⊂RPT⊃⊗D DELETES LINE.
⊗⊂RPT⊃C DUPLICATES A NUMBER OF LINES.
⊗Q DUPLICATES A LINE ABOVE CURRENT AND MOVES ARROW TO IT.
α⊂SPACE⊃ MOVES CURSOR TO THE RIGHT. α⊂VT⊃ MOVES IT BACK.
TY⊂FILENAME⊃ TO TYPE A FILE ON THE MONITER.
α⊂BREAK⊃ STOPS SCROLLING.
α⊂TAB⊃ MOVES CURSOR TO END OF LINE.
α ⊂CR⊃ TO CONTINUE A PROGRAM IF YOU CUT YOURSELF OFF.
INSERT MODE
⊗⊂CR⊃ ENTERS INSERT MODE.
α⊂CR⊃ LEAVE INSERT MODE.
⊂ALT⊃ ELIMINATES THE GAP IF NOTHING IS ENTERED ON LINE.
⊂RPT#⊃⊗⊂CR⊃ INSERTS BLANK LINES WITHOUT ENTERING INSERT MODE.
ATTACH MODE
⊂RPT⊃|⊗F⊗R ENTERS ATTACH MODE
⊗E TERMINATES AND UPDATES LOCATION OF ATTACHED LINE.
⊗R RETURNS LINES TO ORIGINAL PLACE
⊗K KILLS LINES ATTACHED.
⊗E LEAVES ATTACH MODE.
EXTEND MODE
⊗X ENTERS THE MODE.
⊗X "MARK" MOVES MATERIAL BELOW ARROW TO NEXT PAGE.
⊗X "DELETE" ELIMINATES PAGE MARK BETWEEN ONE PAGE AND THE NEXT.
TO BREAK A LINE
⊗⊂CR⊃ BREAKS THE LINE AT CURSOR AND ENTERS INSERT MODE.
β⊂CR⊃ " " " " " BUT NOTHING ELSE.
(α⊂CR⊃ INDICATES LINE TOO WIDE IF LINE INDENTS TO LEFT.)
TO INSERT IN A LINE
β⊂LETTERS⊃|⊂SPACE⊃|⊂TAB⊃|⊂BS⊃.
αI TO ADD CHARACTERS IN A LINE WITHOUT HAVING TO HOLD DOWN THE β KEY.
SEARCH MODE
⊗F⊂STATEMENT STRING⊃ FINDS THE VERBATEM STRING, COUNTS LINES TO THAT LINE,
⊗X FIND_⊂STRING⊃⊂CR⊃. SEARCHES ACROSS PAGES TO FIND THE STRING.
αS ⊂STRING⊃ MOVES CURSOR WITHIN LINE TO THE STRING LOCATION.
******
TV EDITOR COMMANDS
TV EDIT A FILE WITH TV.
CTV CREATE A FILE WITH TV.
⊗X "SWITCH"⊂FILENAME⊃ MOVES ATTACHED LINES TO NEW FILE.
******
TO MOVE INFORMATION BETWEEN FILES
TV ⊂File with info⊃ to locate it.
→ place cursor at top of info.
⊗F⊂bottom line of info⊃⊗A to attach info.
⊗X SWITCH ⊂filename of destination file⊃.
******
AIDS TO EDITING
DIR lists all files on the disk in this prj,prg.
DEL ⊂filename⊃ will delete that file.
DEL *.*[PRG,PRJ]/ASK will sequence through files asking to save or not.
α⊂CR⊃ IF THE MONITOR DIDN'T LIKE YOUR COMMAND, WILL PUT IT IN EDIT MODE.
******
JUSTIFYING PAGES
⊗A TO BOTTOM LINE, THEN ⊗X JU.